/**
 * 给定数组，三种可能的操作：
 * 1. 交换两个元素，无代价
 * 2. 将 ai+=1 或 ai-=1，代价100
 * 3. 将 ai+=2 或 ai-=2，代价1
 * 任意次操作将数组调为公差为2的等差数列，求最小代价
 * 首先必然是在排序的数组基础上进行加减操作，如此代价最低，基于贪心的思维，也可以不严格的证明一下
 * 其次做一个常规操作，令 Ai -= (i - 1) * 2
 * 这样目标从调等差数列变为了把所有Ai调相等
 * 设调整的目标为target，即将所有Ai调整为target所需的最小代价
 * 在将A排序，记作A[1...N]，同样基于贪心可知，target定为Ai最有可能达到最小
 * 考虑到代价是分奇偶的，所以候选的target应该为{Ai, Ai + 1, Ai - 1}。
 * 对每一个target，假设小于等于target的Ai一共有c个，且奇偶相异的有yc个，则
 * 将小于target的数调为target需要付出的代价为  (c * target - S[c] - yc) / 2 + yc * 100
 * 将大于target的数调为Ai的代价是
 *    (S[N] - S[c] - (N - c) * target - yyc) / 2 + yyc * 100
 * 其中yyc是比target大的且奇偶异性的Ai的数量
 */
#include <bits/stdc++.h>
using namespace std;

using llt = long long;
using vi = vector<int>;
using pii = pair<int, int>;

int N;
vector<llt> A;
vector<llt> Sum;
vector<array<int, 2>> Cnt;

void chkmin(llt & a, llt b){
    if(-1 == a or a > b) a = b;
}

llt proc(llt target, int left){
    assert(target >= 1);
    int jo = target & 1;

    const auto & cnts = Cnt[left];
    int tongcnt = cnts[jo];
    int yicnt = cnts[jo ^ 1];
    assert(tongcnt + yicnt == left);

    llt cha = left * target - Sum[left];
    assert(cha >= yicnt);
    cha -= yicnt;
    assert(0 == cha % 2);

    llt ans = cha / 2 + yicnt * 100LL;

    tongcnt = Cnt[N][jo] - tongcnt;
    yicnt = Cnt[N][jo ^ 1] - yicnt;
    assert(tongcnt + yicnt == N - left);

    cha = Sum[N] - Sum[left] - (N - left) * target;
    assert(cha >= yicnt);
    cha -= yicnt;
    assert(0 == cha % 2);
    ans += cha / 2 + yicnt * 100LL;

    return ans;
}

llt proc(){
    sort(A.begin() + 1, A.end());
    for(int i=1,j=0;i<=N;++i,j+=2) A[i] -= j;
    sort(A.begin() + 1, A.end());
    auto mmin = A[1] - 1;
    for(int i=1;i<=N;++i) A[i] -= mmin;

    Sum.assign(N + 1, 0LL);
    Cnt.assign(N + 1, {0, 0});
    for(int i=1;i<=N;++i){
        assert(A[i] >= 1);
        assert(A[i - 1] <= A[i]);
        Sum[i] = Sum[i - 1] + A[i];
        Cnt[i] = Cnt[i - 1];
        Cnt[i][A[i] & 1] += 1;
    }
    llt ans = -1;
    for(int i=1;i<=N;++i){
        if(A[i] == A[i - 1]) continue;

        int target = A[i];
        chkmin(ans, proc(target, i));

        if(i > 1){
            target = A[i] - 1;
            if(target > A[i - 1]){
                chkmin(ans, proc(target, i - 1));
            }
            
        }
        
        if(i < N){
            target = A[i] + 1;
            if(target < A[i + 1]){
                chkmin(ans, proc(target, i));
            }            
        }
    }
    assert(-1 != ans);
    return ans;
}

void work(){
    cin >> N;
    A.assign(N + 1, 0);
    for(int i=1;i<=N;++i) cin >> A[i];
    cout << proc() << endl;
    return;
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("z.txt", "r", stdin);
#endif
    ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);

    int nofkase = 1;
    // cin >> nofkase;
    while(nofkase--) work();
    return 0;
}
